const express = require('express');
const router = express.Router();
const { generateToken, verifyToken, verifyAdmin } = require('../middleware/auth');

// 根据环境变量选择使用真实数据库还是模拟数据
const USE_MONGO = process.env.USE_MONGO !== 'false';
const User = USE_MONGO 
  ? require('../models/User')
  : require('../models/MockUser');

/**
 * @route   POST /api/auth/register
 * @desc    注册新用户
 * @access  公开
 */
router.post('/register', async (req, res) => {
  try {
    const { username, email, password } = req.body;

    // 检查用户名是否已存在
    let user = await User.findOne({ username });
    if (user) {
      return res.status(400).json({ error: '用户名已存在' });
    }

    // 检查邮箱是否已存在
    user = await User.findOne({ email });
    if (user) {
      return res.status(400).json({ error: '邮箱已被注册' });
    }

    // 创建默认为普通用户
    user = new User({
      username,
      email,
      password,
      role: 'user',
      permissions: {
        system: true,
        file: true,
        nginx: false,
        database: false,
        security: false,
        task: false,
        app: false
      }
    });

    // 如果是第一个用户，设为管理员
    const userCount = await User.countDocuments();
    if (userCount === 0) {
      user.role = 'admin';
    }

    await user.save();

    // 生成令牌
    const token = generateToken(user);

    res.status(201).json({
      token,
      user: {
        id: user._id,
        username: user.username,
        email: user.email,
        role: user.role,
        permissions: user.permissions
      }
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

/**
 * @route   POST /api/auth/login
 * @desc    用户登录
 * @access  公开
 */
router.post('/login', async (req, res) => {
  try {
    const { username, password } = req.body;

    // 硬编码的管理员账号
    if (username === 'admin' && password === '123456') {
      console.log('使用硬编码的管理员账号登录');
      // 创建一个默认管理员用户对象
      const adminUser = {
        _id: 'admin-123456',
        username: 'admin',
        email: 'admin@example.com',
        role: 'admin',
        permissions: {
          system: true,
          file: true,
          nginx: true,
          database: true,
          security: true,
          task: true,
          app: true
        },
        lastLogin: new Date(),
        active: true
      };

      // 生成令牌
      const token = generateToken(adminUser);

      return res.json({
        token,
        user: {
          id: adminUser._id,
          username: adminUser.username,
          email: adminUser.email,
          role: adminUser.role,
          permissions: adminUser.permissions
        }
      });
    } else {
      // 在非数据库模式下，只接受硬编码的账号
      if (process.env.USE_MONGO === 'false') {
        return res.status(401).json({ error: '无效的用户名或密码' });
      }

      // 正常的数据库查询登录逻辑（如果硬编码未匹配且在数据库模式下）
      // 查找用户
      const user = await User.findOne({ username });
      if (!user) {
        return res.status(401).json({ error: '无效的用户名或密码' });
      }

      // 验证密码
      const isMatch = await user.comparePassword(password);
      if (!isMatch) {
        return res.status(401).json({ error: '无效的用户名或密码' });
      }

      // 检查用户是否被停用
      if (!user.active) {
        return res.status(403).json({ error: '账户已被停用' });
      }

      // 更新最后登录时间
      user.lastLogin = Date.now();
      await user.save();

      // 生成令牌
      const token = generateToken(user);

      res.json({
        token,
        user: {
          id: user._id,
          username: user.username,
          email: user.email,
          role: user.role,
          permissions: user.permissions
        }
      });
    }
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

/**
 * @route   GET /api/auth/profile
 * @desc    获取用户个人资料
 * @access  私有
 */
router.get('/profile', verifyToken, async (req, res) => {
  try {
    const user = await User.select('-password').findById(req.user.id);
    if (!user) {
      return res.status(404).json({ error: '用户不存在' });
    }

    res.json(user);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

/**
 * @route   PUT /api/auth/profile
 * @desc    更新用户个人资料
 * @access  私有
 */
router.put('/profile', verifyToken, async (req, res) => {
  try {
    const { email, currentPassword, newPassword } = req.body;
    const user = await User.findById(req.user.id);

    if (!user) {
      return res.status(404).json({ error: '用户不存在' });
    }

    // 更新邮箱
    if (email && email !== user.email) {
      const emailExists = await User.findOne({ email });
      if (emailExists) {
        return res.status(400).json({ error: '邮箱已被其他用户使用' });
      }
      user.email = email;
    }

    // 更新密码
    if (currentPassword && newPassword) {
      const isMatch = await user.comparePassword(currentPassword);
      if (!isMatch) {
        return res.status(400).json({ error: '当前密码不正确' });
      }
      user.password = newPassword;
    }

    await user.save();

    res.json({
      message: '个人资料已更新',
      user: {
        id: user._id,
        username: user.username,
        email: user.email,
        role: user.role,
        permissions: user.permissions
      }
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

/**
 * @route   GET /api/auth/users
 * @desc    获取所有用户列表（仅管理员）
 * @access  仅管理员
 */
router.get('/users', [verifyToken, verifyAdmin], async (req, res) => {
  try {
    const users = await User.select('-password').find();
    res.json(users);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

/**
 * @route   PUT /api/auth/users/:id
 * @desc    更新用户（仅管理员）
 * @access  仅管理员
 */
router.put('/users/:id', [verifyToken, verifyAdmin], async (req, res) => {
  try {
    const { role, permissions, active } = req.body;
    const user = await User.findById(req.params.id);

    if (!user) {
      return res.status(404).json({ error: '用户不存在' });
    }

    // 确保不能降级自己的管理员身份
    if (user._id.toString() === req.user.id && role === 'user') {
      return res.status(400).json({ error: '无法降级自己的管理员身份' });
    }

    // 更新角色
    if (role) {
      user.role = role;
    }

    // 更新权限
    if (permissions) {
      user.permissions = permissions;
    }

    // 更新激活状态
    if (active !== undefined) {
      // 确保不能停用自己
      if (user._id.toString() === req.user.id && !active) {
        return res.status(400).json({ error: '无法停用自己的账户' });
      }
      user.active = active;
    }

    await user.save();

    res.json({
      message: '用户已更新',
      user: {
        id: user._id,
        username: user.username,
        email: user.email,
        role: user.role,
        permissions: user.permissions,
        active: user.active
      }
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

/**
 * @route   DELETE /api/auth/users/:id
 * @desc    删除用户（仅管理员）
 * @access  仅管理员
 */
router.delete('/users/:id', [verifyToken, verifyAdmin], async (req, res) => {
  try {
    // 不允许删除自己
    if (req.params.id === req.user.id) {
      return res.status(400).json({ error: '不能删除自己的账户' });
    }

    const user = await User.findById(req.params.id);
    if (!user) {
      return res.status(404).json({ error: '用户不存在' });
    }

    if (USE_MONGO) {
      await user.remove();
    } else {
      // 在模拟模式下，我们只能标记用户为非活动状态，因为没有实现remove方法
      user.active = false;
      await user.save();
    }

    res.json({ message: '用户已删除' });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

module.exports = router; 